{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# avoid non-compliant Type 3 fonts\n",
    "import matplotlib\n",
    "matplotlib.rcParams['pdf.fonttype'] = 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.backends.cudnn as cudnn\n",
    "import torch.utils.data\n",
    "import torchvision.transforms as transforms\n",
    "from munch import Munch\n",
    "from skimage.draw import circle\n",
    "from skimage.measure import find_contours\n",
    "from tqdm import tqdm_notebook as tqdm\n",
    "from PIL import Image\n",
    "\n",
    "import models\n",
    "import utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_circle_size = 48\n",
    "num_circles = 16\n",
    "cache_dir = 'cache/occlusion_study/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "config_path = 'pretrained/floating_kinect1_mask/config.yml'\n",
    "#config_path = 'pretrained/floating_kinect1_mask_with_occlusion/config.yml'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(config_path, 'r') as f:\n",
    "    cfg = Munch.fromYAML(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=> loaded checkpoint 'pretrained/floating_kinect1_mask/checkpoint_00002100.pth.tar' (epoch 2100)\n"
     ]
    }
   ],
   "source": [
    "model = models.Model(cfg.arch)\n",
    "model = torch.nn.DataParallel(model).cuda()\n",
    "cudnn.benchmark = True\n",
    "checkpoint = torch.load(cfg.training.resume)\n",
    "model.load_state_dict(checkpoint['state_dict'])\n",
    "model.eval()\n",
    "print(\"=> loaded checkpoint '{}' (epoch {})\".format(cfg.training.resume, checkpoint['epoch']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class OccludedRenderedPoseMaskDataset(torch.utils.data.Dataset):\n",
    "    def __init__(self, data_root, objects, subset_num, transform, max_circle_size, num_circles):\n",
    "        self.transform = transform\n",
    "        self.num_circles = num_circles\n",
    "\n",
    "        # images\n",
    "        image_dirs = []\n",
    "        self.object_indices = []\n",
    "\n",
    "        for o in objects:\n",
    "            image_dirs.append(os.path.join(data_root, o, 'subset_{:08}'.format(subset_num)))\n",
    "        for image_dir in image_dirs:\n",
    "            assert os.path.exists(image_dir)\n",
    "        self.image_paths = []\n",
    "        for i, image_dir in enumerate(image_dirs):\n",
    "            image_names = sorted(os.listdir(image_dir))\n",
    "            self.image_paths.extend([os.path.join(image_dir, name) for name in image_names])\n",
    "            self.object_indices.extend(i * np.ones(len(image_names)))\n",
    "        self.object_indices = np.array(self.object_indices, dtype=np.int64)\n",
    "        assert len(self.object_indices) == len(self.image_paths)\n",
    "\n",
    "        # poses\n",
    "        poses_paths = []\n",
    "        for o in objects:\n",
    "            poses_paths.append(os.path.join(data_root, o, 'poses', 'subset_{:08}.txt'.format(subset_num)))\n",
    "        for poses_path in poses_paths:\n",
    "            assert os.path.exists(poses_path)\n",
    "        self.poses = []\n",
    "        for poses_path in poses_paths:\n",
    "            self.poses.extend(np.loadtxt(poses_path).astype(np.float32))\n",
    "        assert len(self.poses) == len(self.image_paths)\n",
    "\n",
    "        # precompute circular occlusions\n",
    "        print('precomputing circular occlusions')\n",
    "        random_state = np.random.RandomState(0)\n",
    "        self.circle_sizes = max_circle_size * random_state.rand(self.num_circles * len(self.image_paths))\n",
    "        self.circle_centers = []\n",
    "        for image_path in tqdm(self.image_paths):\n",
    "            contours = find_contours(np.asarray(Image.open(image_path)), 0)\n",
    "            if len(contours) > 0:\n",
    "                contour = sorted(contours, key=lambda x: -x.shape[0])[0]\n",
    "            if len(contours) > 0 and len(contour) >= self.num_circles:\n",
    "                contour_indices = random_state.choice(len(contour), self.num_circles, replace=False)\n",
    "                self.circle_centers.extend(contour[contour_indices])\n",
    "            else:\n",
    "                # object is probably out of image or too small to occlude\n",
    "                self.circle_centers.extend(self.num_circles * [None])\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        image_index = index // self.num_circles\n",
    "        object_index = self.object_indices[image_index]\n",
    "\n",
    "        image = Image.open(self.image_paths[image_index])\n",
    "        occlusion_amount = 0\n",
    "\n",
    "        # apply precomputed circular occlusion if possible\n",
    "        if self.circle_centers[index] is not None:\n",
    "            np_image = np.asarray(image)\n",
    "            occluded_image = np_image.copy()\n",
    "            r, c = self.circle_centers[index]\n",
    "            circle_size = self.circle_sizes[index]\n",
    "            rr, cc = circle(r, c, circle_size, shape=np_image.shape)\n",
    "            occluded_image[rr, cc] = 0\n",
    "            occlusion_amount = 1 - float(occluded_image.sum()) / np_image.sum()\n",
    "            image = Image.fromarray(occluded_image)\n",
    "\n",
    "        image = self.transform(image)\n",
    "\n",
    "        # enforce quaternion [w, x, y, z] to have positive w\n",
    "        target_pose = self.poses[image_index]\n",
    "        if target_pose[3] < 0:\n",
    "            target_pose[3:] = -target_pose[3:]\n",
    "\n",
    "        return image, target_pose, object_index, occlusion_amount\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.num_circles * len(self.image_paths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "precomputing circular occlusions\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a46ce0ed109143de91853e6d29a6eaa3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3200), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "transform = transforms.ToTensor()\n",
    "val_dataset = OccludedRenderedPoseMaskDataset(\n",
    "    cfg.data.root, cfg.data.objects, cfg.data.val_subset_num, transform, max_circle_size, num_circles)\n",
    "val_loader = torch.utils.data.DataLoader(\n",
    "    val_dataset, batch_size=1, shuffle=True, num_workers=0, pin_memory=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# visualize\n",
    "#for image, _, _, occlusion_amount in val_loader:\n",
    "#    plt.imshow(image[0].numpy()[0], cmap='gray')\n",
    "#    plt.show()\n",
    "#    print(occlusion_amount[0].item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forward_batch(model, input, target, object_index):\n",
    "    target = target.cuda(non_blocking=True)\n",
    "    object_index = object_index.cuda(non_blocking=True)\n",
    "\n",
    "    position, orientation = model(input, object_index)\n",
    "    position_error = (target[:, :3] - position).pow(2).sum(dim=1).sqrt()\n",
    "    orientation_error = 180.0 / np.pi * utils.batch_rotation_angle(target[:, 3:], orientation)\n",
    "\n",
    "    return position_error.cpu().numpy(), orientation_error.cpu().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0f0d134a587b48789b2c72117ba7afed",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=51200), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "occlusion_amounts = []\n",
    "position_errors = []\n",
    "orientation_errors = []\n",
    "with torch.no_grad():\n",
    "    for input, target, object_index, occlusion_amount in tqdm(val_loader):\n",
    "        position_error, orientation_error = forward_batch(model, input, target, object_index)\n",
    "        occlusion_amounts.extend(occlusion_amount)\n",
    "        position_errors.extend(position_error)\n",
    "        orientation_errors.extend(orientation_error)\n",
    "position_errors = 100.0 * np.array(position_errors)\n",
    "orientation_errors = np.array(orientation_errors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_bins = 100\n",
    "bin_edges = np.linspace(0, 1, num_bins + 1)\n",
    "left_edges = bin_edges[:num_bins]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "170d52605269471081beac28ed117061",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "p_mean = []\n",
    "o_mean = []\n",
    "for i in tqdm(range(num_bins)):\n",
    "    mask = (bin_edges[i] <= occlusion_amounts) & (occlusion_amounts < bin_edges[i + 1])\n",
    "    p_mean.append(position_errors[mask].mean())\n",
    "    o_mean.append(orientation_errors[mask].mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(cache_dir):\n",
    "    os.makedirs(cache_dir)\n",
    "cache_path = os.path.join(cache_dir, '{}.npy'.format(cfg.training.experiment_name))\n",
    "np.save(cache_path, (p_mean, o_mean))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "cache_path_wo_occlusion = os.path.join(cache_dir, '{}.npy'.format('floating_kinect1_mask'))\n",
    "cache_path_with_occlusion = os.path.join(cache_dir, '{}.npy'.format('floating_kinect1_mask_with_occlusion'))\n",
    "p_mean_wo_occlusion, o_mean_wo_occlusion = np.load(cache_path_wo_occlusion)\n",
    "p_mean_with_occlusion, o_mean_with_occlusion = np.load(cache_path_with_occlusion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = plt.subplot(111)\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "ax.tick_params(axis='both', which='major', labelsize=16)\n",
    "ax.tick_params(axis='both', which='minor', labelsize=16)\n",
    "plt.plot(left_edges, p_mean_wo_occlusion, color='gray', lw=1, label='trained without occlusion')\n",
    "plt.plot(left_edges, p_mean_with_occlusion, color='darkmagenta', lw=1, label='trained with occlusion')\n",
    "plt.xlim(0, 1)\n",
    "plt.ylim(0, 90)\n",
    "plt.xlabel('occlusion amount', fontsize=18)\n",
    "plt.ylabel('mean position error (cm)', fontsize=18)\n",
    "plt.legend(prop={'size': 14})\n",
    "plt.savefig('figures/occlusion_position.pdf', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = plt.subplot(111)\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "ax.tick_params(axis='both', which='major', labelsize=16)\n",
    "ax.tick_params(axis='both', which='minor', labelsize=16)\n",
    "plt.plot(left_edges, o_mean_wo_occlusion, color='gray', lw=1, label='trained without occlusion')\n",
    "plt.plot(left_edges, o_mean_with_occlusion, color='darkmagenta', lw=1, label='trained with occlusion')\n",
    "plt.xlim(0, 1)\n",
    "plt.ylim(0, 130)\n",
    "plt.xlabel('occlusion amount', fontsize=18)\n",
    "plt.ylabel('mean orientation error (deg)', fontsize=18)\n",
    "plt.legend(prop={'size': 14})\n",
    "plt.savefig('figures/occlusion_orientation.pdf', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
